home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Software Vault: The Gold Collection
/
Software Vault - The Gold Collection (American Databankers) (1993).ISO
/
cdr25
/
dkb32.zip
/
DKB32SRC.ZIP
/
PLANES.C
< prev
next >
Wrap
C/C++ Source or Header
|
1991-05-04
|
7KB
|
230 lines
/*****************************************************************************
*
* planes.c
*
* from DKBTrace (c) 1990 David Buck
*
* This module implements functions that manipulate planes.
*
* This software is freely distributable. The source and/or object code may be
* copied or uploaded to communications services so long as this notice remains
* at the top of each file. If any changes are made to the program, you must
* clearly indicate in the documentation and in the programs startup message
* who it was who made the changes. The documentation should also describe what
* those changes were. This software may not be included in whole or in
* part into any commercial package without the express written consent of the
* author. It may, however, be included in other public domain or freely
* distributed software so long as the proper credit for the software is given.
*
* This software is provided as is without any guarantees or warranty. Although
* the author has attempted to find and correct any bugs in the software, he
* is not responsible for any damage caused by the use of the software. The
* author is under no obligation to provide service, corrections, or upgrades
* to this package.
*
* Despite all the legal stuff above, if you do find bugs, I would like to hear
* about them. Also, if you have any comments or questions, you may contact me
* at the following address:
*
* David Buck
* 22C Sonnet Cres.
* Nepean Ontario
* Canada, K2H 8W7
*
* I can also be reached on the following bulleton boards:
*
* OMX (613) 731-3419
* Mystic (613) 596-4249 or (613) 596-4772
*
* Fidonet: 1:163/109.9
* Internet: dbuck@ccs.carleton.ca
* The "You Can Call Me RAY" BBS (708) 358-5611
*
* IBM Port by Aaron A. Collins. Aaron may be reached on the following BBS'es:
*
* The "You Can Call Me RAY" BBS (708) 358-5611
* The Information Exchange BBS (708) 945-5575
*
*****************************************************************************/
#include "frame.h"
#include "vector.h"
#include "dkbproto.h"
METHODS Plane_Methods =
{ Object_Intersect, All_Plane_Intersections,
Inside_Plane, Plane_Normal,
Copy_Plane,
Translate_Plane, Rotate_Plane,
Scale_Plane, Invert_Plane};
extern PLANE *Get_Plane_Shape();
extern RAY *VP_Ray;
extern long Ray_Plane_Tests, Ray_Plane_Tests_Succeeded;
int All_Plane_Intersections (Object, Ray, Depth_Queue)
OBJECT *Object;
RAY *Ray;
PRIOQ *Depth_Queue;
{
PLANE *Shape = (PLANE *) Object;
DBL Depth;
VECTOR Intersection_Point;
INTERSECTION Local_Element;
if (Intersect_Plane (Ray, Shape, &Depth))
if (Depth > Small_Tolerance)
{
Local_Element.Depth = Depth;
Local_Element.Object = Shape -> Parent_Object;
VScale (Intersection_Point, Ray -> Direction, Depth);
VAdd (Intersection_Point, Intersection_Point, Ray -> Initial);
Local_Element.Point = Intersection_Point;
Local_Element.Shape = (SHAPE *)Shape;
pq_add (Depth_Queue, &Local_Element);
return (TRUE);
}
return (FALSE);
}
int Intersect_Plane (Ray, Plane, Depth)
RAY *Ray;
PLANE *Plane;
DBL *Depth;
{
DBL NormalDotOrigin, NormalDotDirection;
Ray_Plane_Tests++;
if (Ray == VP_Ray) {
if (!Plane->VPCached) {
VDot (Plane->VPNormDotOrigin, Plane->Normal_Vector, Ray->Initial);
Plane->VPNormDotOrigin += Plane->Distance;
Plane->VPNormDotOrigin *= -1.0;
Plane->VPCached = TRUE;
}
VDot (NormalDotDirection, Plane->Normal_Vector, Ray->Direction);
if ((NormalDotDirection < Small_Tolerance) &&
(NormalDotDirection > -Small_Tolerance))
return (FALSE);
*Depth = Plane->VPNormDotOrigin / NormalDotDirection;
if ((*Depth >= Small_Tolerance) && (*Depth <= Max_Distance)) {
Ray_Plane_Tests_Succeeded++;
return (TRUE);
}
else
return (FALSE);
}
else {
VDot (NormalDotOrigin, Plane->Normal_Vector, Ray->Initial);
NormalDotOrigin += Plane->Distance;
NormalDotOrigin *= -1.0;
VDot (NormalDotDirection, Plane->Normal_Vector, Ray->Direction);
if ((NormalDotDirection < Small_Tolerance) &&
(NormalDotDirection > -Small_Tolerance))
return (FALSE);
*Depth = NormalDotOrigin / NormalDotDirection;
if ((*Depth >= Small_Tolerance) && (*Depth <= Max_Distance)) {
Ray_Plane_Tests_Succeeded++;
return (TRUE);
}
else
return (FALSE);
}
}
int Inside_Plane (Test_Point, Object)
VECTOR *Test_Point;
OBJECT *Object;
{
PLANE *Plane = (PLANE *) Object;
DBL Temp;
VDot (Temp, *Test_Point, Plane->Normal_Vector);
return ((Temp + Plane->Distance) <= Small_Tolerance);
}
void Plane_Normal (Result, Object, Intersection_Point)
OBJECT *Object;
VECTOR *Result, *Intersection_Point;
{
PLANE *Plane = (PLANE *) Object;
*Result = Plane->Normal_Vector;
}
void *Copy_Plane (Object)
OBJECT *Object;
{
PLANE *New_Shape;
New_Shape = Get_Plane_Shape ();
*New_Shape = * ((PLANE *)Object);
New_Shape -> Next_Object = NULL;
if (New_Shape->Shape_Texture != NULL)
New_Shape->Shape_Texture = Copy_Texture (New_Shape->Shape_Texture);
return (New_Shape);
}
void Translate_Plane (Object, Vector)
OBJECT *Object;
VECTOR *Vector;
{
PLANE *Plane = (PLANE *) Object;
VECTOR Translation;
VEvaluate (Translation, Plane->Normal_Vector, *Vector);
Plane->Distance -= Translation.x + Translation.y + Translation.z;
Translate_Texture (&Plane->Shape_Texture, Vector);
}
void Rotate_Plane (Object, Vector)
OBJECT *Object;
VECTOR *Vector;
{
TRANSFORMATION Transformation;
Get_Rotation_Transformation (&Transformation, Vector);
MTransformVector (&((PLANE *) Object)->Normal_Vector,
&((PLANE *) Object)->Normal_Vector, &Transformation);
Rotate_Texture (&((PLANE *) Object)->Shape_Texture, Vector);
}
void Scale_Plane (Object, Vector)
OBJECT *Object;
VECTOR *Vector;
{
DBL Length;
PLANE *Plane = (PLANE *) Object;
Plane->Normal_Vector.x = Plane->Normal_Vector.x / Vector->x;
Plane->Normal_Vector.y = Plane->Normal_Vector.y / Vector->y;
Plane->Normal_Vector.z = Plane->Normal_Vector.z / Vector->z;
VLength(Length, Plane->Normal_Vector);
VScale (Plane->Normal_Vector, Plane->Normal_Vector, 1.0 / Length);
Plane->Distance /= Length;
Scale_Texture (&((PLANE *) Object)->Shape_Texture, Vector);
}
void Invert_Plane (Object)
OBJECT *Object;
{
PLANE *Plane = (PLANE *) Object;
VScale (Plane->Normal_Vector, Plane->Normal_Vector, -1.0);
Plane->Distance *= -1.0;
}